// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
})

const db = cloud.database()
const gameSaveCollection = db.collection('gameSaves')

// 云函数入口函数
exports.main = async (event, context) => {
  // 打印完整的输入参数，用于调试
  console.log('云函数入口 - 完整输入参数:', JSON.stringify(event));
  
  const { action, data } = event
  const wxContext = cloud.getWXContext()
  const userId = wxContext.OPENID || data.userId // 优先使用小程序环境的OPENID，否则使用传入的userId
  
  console.log('云函数入口 - 解析后的参数:', { action, userId });
  console.log('云函数入口 - data参数:', JSON.stringify(data));

  switch (action) {
    case 'save':
      // 特别检查gameName是否正确传递
      console.log('云函数入口 - 准备调用saveGame，检查gameName:', data.gameName);
      return await saveGame({...data, userId})
    case 'load':
      return await loadGame({...data, userId})
    case 'delete':
      return await deleteGame({...data, userId})
    case 'list':
      return await listSaves({...data, userId})
    default:
      return {
        code: -1,
        msg: '未知操作类型'
      }
  }
}

/**
 * 保存游戏进度
 * @param {Object} data 游戏存档数据
 */
async function saveGame(data) {
  try {
    // 打印完整的输入数据，用于调试
    console.log('saveGame - 输入数据:', JSON.stringify(data));
    
    // 确保提取正确的参数
    const { userId, saveId, gameName, gameData } = data;
    
    // 特别处理存档名称，确保优先使用传入的名称
    let finalGameName = '自动存档'; // 默认值改为"自动存档"
    if (typeof gameName === 'string' && gameName.trim()) {
      finalGameName = gameName.trim();
      console.log('saveGame - 使用传入的存档名称:', finalGameName);
    }
    
    console.log('saveGame - 最终使用的存档名称:', finalGameName);
    console.log('saveGame - 处理后的参数:', {
      userId,
      saveId,
      gameName: finalGameName,
      hasGameData: !!gameData
    });
    
    if (!userId) {
      return {
        code: -1,
        msg: '用户ID不能为空'
      }
    }

    if (!gameData) {
      return {
        code: -1,
        msg: '游戏数据不能为空'
      }
    }

    // 确保存档数据中包含正确的存档名称
    const saveData = {
      userId,
      gameName: finalGameName, // 使用处理后的存档名称
      gameData,
      updateTime: db.serverDate()
    }

    let result;
    
    // 如果有存档ID，则更新存档，否则创建新存档
    if (saveId) {
      console.log('saveGame - 更新存档, saveId:', saveId);
      result = await gameSaveCollection.doc(saveId).update({
        data: saveData
      });
      
      console.log('saveGame - 更新结果:', result);
      
      return {
        code: 0,
        msg: '更新游戏存档成功',
        data: {
          saveId,
          gameName: finalGameName,
          ...result
        }
      }
    } else {
      console.log('saveGame - 创建新存档');
      saveData.createTime = db.serverDate();
      result = await gameSaveCollection.add({
        data: saveData
      });
      
      console.log('saveGame - 创建结果:', result);
      
      // 创建成功后，再次查询刚创建的存档，确保返回完整数据
      try {
        const newSaveId = result._id;
        const newSave = await gameSaveCollection.doc(newSaveId).get();
        console.log('saveGame - 查询新创建的存档:', newSave);
        
        return {
          code: 0,
          msg: '创建游戏存档成功',
          data: {
            saveId: newSaveId,
            gameName: finalGameName,
            ...newSave.data
          }
        }
      } catch (queryError) {
        console.error('查询新创建的存档失败:', queryError);
        
        return {
          code: 0,
          msg: '创建游戏存档成功',
          data: {
            saveId: result._id,
            gameName: finalGameName,
            ...result
          }
        }
      }
    }
  } catch (error) {
    console.error('保存游戏失败', error);
    return {
      code: -1,
      msg: '保存游戏失败: ' + error.message,
      error
    }
  }
}

/**
 * 加载游戏存档
 * @param {Object} data 包含存档ID和用户ID
 */
async function loadGame(data) {
  try {
    const { userId, saveId } = data
    
    if (!userId) {
      return {
        code: -1,
        msg: '用户ID不能为空'
      }
    }

    if (!saveId) {
      return {
        code: -1,
        msg: '存档ID不能为空'
      }
    }

    const result = await gameSaveCollection.doc(saveId).get()
    
    // 验证存档所有权
    if (result.data.userId !== userId) {
      return {
        code: -1,
        msg: '无权限访问该存档'
      }
    }
    
    return {
      code: 0,
      msg: '加载游戏存档成功',
      data: result.data
    }
  } catch (error) {
    console.error('加载游戏存档失败', error)
    return {
      code: -1,
      msg: '加载游戏存档失败: ' + error.message,
      error
    }
  }
}

/**
 * 删除游戏存档
 * @param {Object} data 包含存档ID和用户ID
 */
async function deleteGame(data) {
  try {
    const { userId, saveId } = data
    
    if (!userId) {
      return {
        code: -1,
        msg: '用户ID不能为空'
      }
    }

    if (!saveId) {
      return {
        code: -1,
        msg: '存档ID不能为空'
      }
    }

    // 先检查存档所有权
    const save = await gameSaveCollection.doc(saveId).get()
    if (save.data.userId !== userId) {
      return {
        code: -1,
        msg: '无权限删除该存档'
      }
    }

    const result = await gameSaveCollection.doc(saveId).remove()
    
    return {
      code: 0,
      msg: '删除游戏存档成功',
      data: result
    }
  } catch (error) {
    console.error('删除游戏存档失败', error)
    return {
      code: -1,
      msg: '删除游戏存档失败: ' + error.message,
      error
    }
  }
}

/**
 * 获取用户的所有游戏存档
 * @param {Object} data 包含用户ID
 */
async function listSaves(data) {
  try {
    const { userId } = data;
    
    if (!userId) {
      return {
        code: -1,
        msg: '用户ID不能为空'
      }
    }

    console.log('listSaves - 查询用户存档，userId:', userId);

    const result = await gameSaveCollection
      .where({
        userId: userId
      })
      .orderBy('updateTime', 'desc')
      .get();
    
    console.log('listSaves - 查询结果:', result);
    
    // 直接返回数据数组，而不是包装在data字段中
    return result.data;
  } catch (error) {
    console.error('获取游戏存档列表失败', error)
    return {
      code: -1,
      msg: '获取游戏存档列表失败: ' + error.message,
      error
    }
  }
}
